﻿using System;
using System.Diagnostics;

namespace Teal.Compiler {

    #region Expression

    /// <summary>
    /// 表示一个表达式。
    /// </summary>
    public abstract partial class Expression {

        /// <summary>
        /// 获取当前表达式解析后的返回值类型。
        /// </summary>
        public virtual TypeReference resolvedType {
            get {
                throw new Unreachable();
            }
        }

        ///// <summary>
        ///// 将当前表达式作为值解析。
        ///// </summary>
        ///// <param name="context">用于存储所有解析信息的上下文对象。</param>
        ///// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
        //public virtual Expression resolveAsValue(ResolveContext context) {
        //    throw new Unreachable();
        //}

        ///// <summary>
        ///// 将当前表达式作为指定类型的值解析。
        ///// </summary>
        ///// <param name="context">用于存储所有解析信息的上下文对象。</param>
        ///// <param name="expectedType">期待的返回类型。如果表达式未返回此类型，则尝试进行转换。</param>
        ///// <param name="explicitCast">指示强制转换为目标类型的方式。</param>
        ///// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
        //public virtual Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast = State.unset) {

        //    // 和语句不同，表达式的意义可能根据上下文变化。
        //    // 如处于类型范围的表达式应解析为类型，
        //    // 处于值范围的表达式应根据需要的返回类型进行解析。
        //    // 因此表达式在解析时区分为 resolveAsXXX，以适应不同上下文的需求。

        //    // 将表达式解析为值时，由于不同的上下文需要不同的返回类型，
        //    // 表达式的解析方式也将发生变化。
        //    // var x = [ 1 ]
        //    // List<short> y = [ 1 ]
        //    // 其中，x 将作为 List<int> 解析，而 y 将作为 List<short> 解析。

        //    var resolvedValue = resolveAsValue(context);
        //    if (resolvedValue == null) {
        //        return null;
        //    }
        //    return ResolveHelper.convertTo(resolvedValue, expectedType, explicitCast, this);
        //}

        ///// <summary>
        ///// 将当前表达式作为值解析，然后隐式转换为指定的类型，同时允许更新 var 的含义。
        ///// </summary>
        ///// <param name="context">用于存储所有解析信息的上下文对象。</param>
        ///// <param name="declareType">声明的类型。如果需要则更新声明类型。</param>
        ///// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
        //public Expression resolveAsValue(ResolveContext context, ref TypeReference declareType) {

        //    // 处理 var a = xx;
        //    if (declareType == PredefinedTypes.var) {
        //        var resolvedValue = resolveAsValue(context);
        //        if (resolvedValue == null) {
        //            declareType = PredefinedTypes.dynamic;
        //            return null;
        //        }

        //        declareType = resolvedValue.resolvedType;

        //        // 处理 var a = fn(); // fn() 返回 void
        //        if (declareType == PredefinedTypes.@void) {
        //            ResolveHelper.checkVaribaleType(declareType, this);
        //        }
        //        return resolvedValue;
        //    }

        //    return resolveAsValue(context, declareType);
        //}

        ///// <summary>
        ///// 获取当前表达式到指定类型的转换类型。
        ///// </summary>
        ///// <param name="targetType">要转换的目标类型。</param>
        ///// <returns>获取转换方式。</returns>
        //public virtual ConversionType classifyConversion(TypeReference targetType) {
        //    return ResolveHelper.classifyConversion(this, resolvedType, targetType);
        //}

    }

    public partial class Variable {
        public bool isEverAssigned;
       public  State declareState;
    }

    #endregion

    //#region Literals

    ///// <summary>
    ///// 表示 null 常量。
    ///// </summary>
    //public partial class NullLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return NullConstant.@default;
    //    }

    //}

    ///// <summary>
    ///// 表示 true 常量。
    ///// </summary>
    //public partial class TrueLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return BoolConstant.@true;
    //    }

    //}

    ///// <summary>
    ///// 表示 false 常量。
    ///// </summary>
    //public partial class FalseLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return BoolConstant.@false;
    //    }

    //}

    ///// <summary>
    ///// 表示一个整数常量。
    ///// </summary>
    //public partial class IntLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return Int32Constant.from(value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 64 位整数常量。
    ///// </summary>
    //public partial class LongLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return Int64Constant.from(value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个浮点数常量。
    ///// </summary>
    //public partial class FloatLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return Float64Constant.from(value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个字符串常量。
    ///// </summary>
    //public partial class StringLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return StringConstant.from(value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个列表表达式。
    ///// </summary>
    //public partial class ListLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        TypeReference elementType = null;
    //        if (values != null) {
    //            bool hasError = false;
    //            for (int i = 0; i < values.Count; i++) {
    //                var resolvedValue = values[i] = values[i].resolveAsValue(context);
    //                if (resolvedValue == null) {
    //                    hasError = true;
    //                    continue;
    //                }
    //                elementType = ResolveHelper.getCommonBaseType(elementType, resolvedValue.resolvedType);
    //            }

    //            if (hasError) {
    //                return null;
    //            }
    //        }

    //        // 无法推导类型时使用 dynamic 。
    //        if (elementType == null) {
    //            elementType = PredefinedTypes.dynamic;
    //        }

    //        _resolvedType = type == TokenType.lBrack ? PredefinedTypes.System_Collections_List_T.makeGenericType(elementType) : PredefinedTypes.System_Array_T.makeGenericType(elementType);
    //        return this;
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为指定类型的值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="expectedType">期待的返回类型。如果表达式未返回此类型，则尝试进行转换。</param>
    //    /// <param name="explicitCast">指示强制转换为目标类型的方式。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast = State.unset) {
    //        var constructorCall = ResolveHelper.invoke(context, expectedType.getAllConstrutors(), null, null, this);
    //        if (constructorCall == null) {
    //            return null;
    //        }

    //        return resolveAsValue(context, new ObjectCreationExpression() {
    //            target = expectedType,
    //            constructorInvocation = constructorCall
    //        }, false);
    //    }

    //    ObjectCreationExpression _instance;

    //    /// <summary>
    //    /// 将当前表达式作为指定类型的值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="expectedType">期待的返回类型。如果表达式未返回此类型，则尝试进行转换。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public Expression resolveAsValue(ResolveContext context, ObjectCreationExpression instance, bool isNew) {

    //        _instance = instance;
    //        _resolvedType = instance.resolvedType;

    //        if (!instance.target.getAllIneterfaceMembers().Contains(PredefinedTypes.System_Collections_IList_T)) {
    //            if (isNew) {
    //                Compiler.error(ErrorCode.none, String.Format("只有实现“{0}”接口的对象才能使用对象初始化", PredefinedTypes.System_Collections_IList_T.fullName), this);
    //            } else {
    //                Compiler.error(ErrorCode.none, String.Format("无法将“{0}”转换为“{1}”", PredefinedTypes.System_Collections_IList_T.fullName, instance.resolvedType.fullName), this);
    //            }
    //            return null;
    //        }

    //        if (values != null) {
    //            bool hasError = false;
    //            var elementType = instance.resolvedType.genericArguments[0];
    //            for (int i = 0; i < values.Count; i++) {
    //                var resolvedValue = values[i] = values[i].resolveAsValue(context, elementType);
    //                if (resolvedValue == null) {
    //                    hasError = true;
    //                    continue;
    //                }
    //            }

    //            if (hasError) {
    //                return null;
    //            }
    //        }
            
    //        return null;
    //    }

    //    /// <summary>
    //    /// 将当前表达式解析为一个符号。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="symbolUsage">当前符号的使用场景。</param>
    //    /// <param name="instance">返回当前符号的所属实例对象。</param>
    //    /// <returns>返回解析后的符号对象。如果解析出现错误则返回 null。</returns>
    //    public override ISymbol resolveAsSymbol(ResolveContext context, SymbolUsage symbolUsage, out Expression instance) {

    //        // 如果是作为参数解析，则返回空参数标记，表示当前表达式需要延时解析。
    //        if (symbolUsage == SymbolUsage.argument) {
    //            instance = this;
    //            return Expression.empty;
    //        }
    //        return base.resolveAsSymbol(context, symbolUsage, out instance);
    //    }

    //    TypeReference _resolvedType;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前表达式到指定类型的转换类型。
    //    /// </summary>
    //    /// <param name="targetType">要转换的目标类型。</param>
    //    /// <returns>获取转换方式。</returns>
    //    public override ConversionType classifyConversion(TypeReference targetType) {

    //        if (targetType.underlyingMember != PredefinedTypes.System_Collections_List_T && targetType.underlyingMember != PredefinedTypes.System_Array_T) {
    //            return ConversionType.none;
    //        }

    //        return ConversionType.identity;
    //    }

    //}

    ///// <summary>
    ///// 表示一个对象常量。
    ///// </summary>
    //public partial class DictLiteral {

    //    TypeReference _resolvedType;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        bool hasError = false;

    //        if (type == TokenType.lBrack) {
    //            TypeReference keyType = null;
    //            TypeReference valueType = null;

    //            for (Property property = properties; property != null; property = property.next) {
    //                property.key = property.key.resolveAsValue(context);
    //                property.value = property.value.resolveAsValue(context);
    //                if (property.key == null) {
    //                    hasError = true;
    //                } else {
    //                    keyType = ResolveHelper.getCommonBaseType(keyType, property.key.resolvedType);
    //                }

    //                if (property.value == null) {
    //                    hasError = true;
    //                } else {
    //                    valueType = ResolveHelper.getCommonBaseType(valueType, property.value.resolvedType);
    //                }
    //            }

    //            if (hasError) {
    //                return null;
    //            }

    //            _resolvedType = PredefinedTypes.System_Collections_Dict_TKey_TValue.makeGenericType(keyType ?? PredefinedTypes.dynamic, valueType ?? PredefinedTypes.dynamic);

    //        } else {
    //            _resolvedType = new TypeReference(MemberType.@class);

    //            for (Property property = properties; property != null; property = property.next) {
    //                var value = property.value = property.value.resolveAsValue(context);
    //                if (value == null) {
    //                    hasError = true;
    //                    continue;
    //                }

    //                _resolvedType.addMember(new FieldReference() {
    //                    returnType = value.resolvedType,
    //                    name = ((Identifier)property.key).value,
    //                    initialValue = value,
    //                });

    //            }

    //            if (hasError) {
    //                return null;
    //            }

    //        }

    //        return this;
    //    }

    //    ObjectCreationExpression _instance;

    //    /// <summary>
    //    /// 将当前表达式作为指定类型的值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="expectedType">期待的返回类型。如果表达式未返回此类型，则尝试进行转换。</param>
    //    /// <param name="explicitCast">指示强制转换为目标类型的方式。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast = State.unset) {

    //        var constructorCall = ResolveHelper.invoke(context, expectedType.getAllConstrutors(), null, null, this);
    //        if (constructorCall == null) {
    //            return null;
    //        }

    //        return resolveAsValue(context, new ObjectCreationExpression() {
    //            target = expectedType,
    //            constructorInvocation = constructorCall
    //        }, false);
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为指定类型的值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="expectedType">期待的返回类型。如果表达式未返回此类型，则尝试进行转换。</param>
    //    /// <param name="explicitCast">指示强制转换为目标类型的方式。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public Expression resolveAsValue(ResolveContext context, ObjectCreationExpression instance, bool isNew) {

    //        _instance = instance;
    //        _resolvedType = instance.resolvedType;

    //        bool hasError = false;

    //        if (type == TokenType.lBrack) {

    //            if (!instance.target.getAllIneterfaceMembers().Contains(PredefinedTypes.System_Collections_IDict_TKey_TValue)) {
    //                if (isNew) {
    //                    Compiler.error(ErrorCode.none, String.Format("只有实现“{0}”接口的对象才能使用对象初始化", PredefinedTypes.System_Collections_IDict_TKey_TValue.fullName), this);
    //                } else {
    //                    Compiler.error(ErrorCode.none, String.Format("无法将“{0}”转换为“{1}”", PredefinedTypes.System_Collections_IDict_TKey_TValue.fullName, instance.resolvedType.fullName), this);
    //                }
                   
    //                return null;
    //            }

    //            for (Property property = properties; property != null; property = property.next) {
    //                property.key = property.key.resolveAsValue(context, instance.resolvedType.genericArguments[0]); property.value = property.value.resolveAsValue(context, instance.resolvedType.genericArguments[1]);
    //                if (property.key == null || property.value == null) {
    //                    hasError = true;
    //                }
    //            }
    //        } else {

    //            for (Property property = properties; property != null; property = property.next) {
    //                var name = ((Identifier)property.key).value;
    //                var members = instance.resolvedType.getAllMembers(name);
    //                if (members == null) {
    //                    Compiler.error(ErrorCode.none, String.Format("“{0}”不存在名称“{1}”", instance.resolvedType.fullName, name), property.key);
    //                    hasError = true;
    //                    continue;
    //                }
    //                property.value = ((ISymbol)members[0]).setValue(context, _instance, property.value, property.key);
    //                if (property.value == null) {
    //                    hasError = true;
    //                }
    //            }
    //        }

    //        if (hasError) {
    //            return null;
    //        }

    //        return this;
    //    }

    //    /// <summary>
    //    /// 获取当前表达式到指定类型的转换类型。
    //    /// </summary>
    //    /// <param name="targetType">要转换的目标类型。</param>
    //    /// <returns>获取转换方式。</returns>
    //    public override ConversionType classifyConversion(TypeReference targetType) {

    //        if (type == TokenType.lBrack) {

    //        } else {

    //            for (Property property = properties; property != null; property = property.next) {
    //                var members = targetType.getAllMembers(((Identifier)property.key).value);
    //                if (members[0].memberType != MemberType.field && members[0].memberType != MemberType.property) {
    //                    return ConversionType.none;
    //                }
    //            }

    //            return ConversionType.identity;
    //        }

    //        return base.classifyConversion(targetType);
    //    }

    //    /// <summary>
    //    /// 将当前表达式解析为一个符号。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="symbolUsage">当前符号的使用场景。</param>
    //    /// <param name="instance">返回当前符号的所属实例对象。</param>
    //    /// <returns>返回解析后的符号对象。如果解析出现错误则返回 null。</returns>
    //    public override ISymbol resolveAsSymbol(ResolveContext context, SymbolUsage symbolUsage, out Expression instance) {
    //        // 如果是作为参数解析，则返回空参数标记，表示当前表达式需要延时解析。
    //        if (symbolUsage == SymbolUsage.argument) {
    //            instance = this;
    //            return Expression.empty;
    //        }
    //        return base.resolveAsSymbol(context, symbolUsage, out instance);
    //    }

    //}

    ///// <summary>
    ///// 表示一个区间表达式。
    ///// </summary>
    //public partial class RangeLiteral {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        start = start.resolveAsValue(context, PredefinedTypes.System_Int32);
    //        end = end.resolveAsValue(context, PredefinedTypes.System_Int32);
    //        if (start == null || end == null) {
    //            return null;
    //        }
    //        return this;
    //    }

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Range;
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个函数表达式。
    ///// </summary>
    //public partial class LambdaLiteral {

    //    /// <summary>
    //    /// 获取当前解析类型泛型参数的个数。如果当前类型未解析，则返回 0。
    //    /// </summary>
    //    public int resolvedTypeGenericArgumentCount;

    //    /// <summary>
    //    /// 获取当前函数的主体表达式部分。
    //    /// </summary>
    //    public Expression resolvedReturnBody;

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return base.resolveAsSymbolAndGetValue(context);
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为指定类型的值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="expectedType">期待的返回类型。如果表达式未返回此类型，则尝试进行转换。</param>
    //    /// <param name="explicitCast">指示强制转换为目标类型的方式。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast = State.unset) {

    //        // 在已知要解析的目标类型上下文解析函数。
    //        // 如果类型未知，则不会调用此函数。
    //        // 如果 lambda 出现在参数时，解析重载时会多次调用此函数以找到最匹配的重载。

    //        // 解析参数。
    //        if (!resolveParameters(context)) {
    //            return null;
    //        }

    //        // 确认目标类型可以转换。
    //        if (classifyConversion(expectedType) == ConversionType.none) {
    //            Compiler.error(ErrorCode.none, String.Format("无法将“{0}”转换为“{1}”", PredefinedTypes.System_Collections_List_T.fullName, expectedType.fullName), this);
    //            return null;
    //        }

    //        // 根据目标类型推导参数类型。
    //        int i = 1;
    //        for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next) {
    //            parameter.resolvedType = expectedType.genericArguments[i++];
    //        }

    //        // 解析主体。
    //        if (body != null) {
    //            body.resolve(context, expectedType.genericArguments[0], parameters, context.currentFlowControl);
    //        } else {
    //            resolvedReturnBody = returnBody.resolveAsValue(context, expectedType.genericArguments[0]);
    //        }

    //        return this;
    //    }

    //    /// <summary>
    //    /// 将当前表达式解析为一个符号。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="symbolUsage">当前符号的使用场景。</param>
    //    /// <param name="instance">返回当前符号的所属实例对象。</param>
    //    /// <returns>返回解析后的符号对象。如果解析出现错误则返回 null。</returns>
    //    public override ISymbol resolveAsSymbol(ResolveContext context, SymbolUsage symbolUsage, out Expression instance) {

    //        // 如果 lambda 在解析为参数时，则延时解析，并在 resolveAsValue(context, expectedType, explicitCast)
    //        // 真正解析。否则都在此函数直接解析。

    //        instance = null;

    //        // 解析参数。
    //        if (!resolveParameters(context)) {
    //            return null;
    //        }

    //        // 解析主体。

    //        // 判断参数类型是否确定。
    //        if (parameters != null && parameters.type == null) {

    //            // 解析为参数时，返回一个标记表达式。以便下次调用 resolveAsValue() 继续解析。
    //            if (symbolUsage == SymbolUsage.argument) {
    //                instance = this;
    //                return Expression.empty;
    //            }

    //            // 无法推断参数类型，标记为 dynamic 。
    //            for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next) {
    //                parameter.resolvedType = PredefinedTypes.dynamic;
    //            }
    //        }

    //        TypeReference[] types = new TypeReference[resolvedTypeGenericArgumentCount];
    //        if (body != null) {
    //            body.resolve(context, PredefinedTypes.var, parameters, context.currentFlowControl);
    //            types[0] = body.actualReturnType ?? PredefinedTypes.@void;
    //        } else {
    //            resolvedReturnBody = returnBody.resolveAsValue(context);
    //            types[0] = resolvedReturnBody == null ? PredefinedTypes.dynamic : returnBody.resolvedType;
    //        }

    //        int i = 1;
    //        for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next, i++) {
    //            var type = parameter.resolvedType;
    //            switch (parameter.variableType) {
    //                case VariableType.inParameter:
    //                    break;
    //                case VariableType.refParameter:
    //                    type = PredefinedTypes.System_Func_Ref_T.makeGenericType(type);
    //                    break;
    //                case VariableType.outParameter:
    //                    type = PredefinedTypes.System_Func_Out_T.makeGenericType(type);
    //                    break;
    //            }
    //            types[i] = type;
    //        }

    //        _resolvedType = PredefinedTypes.System_Func_T.makeGenericType(types);
    //        return this;
    //    }

    //    private bool resolveParameters(ResolveContext context) {

    //        // 避免解析两次。
    //        if (resolvedTypeGenericArgumentCount != 0) {
    //            return true;
    //        }

    //        // 包含返回类型。
    //        resolvedTypeGenericArgumentCount++;

    //        bool paramSuccess = true;
    //        for (var parameter = parameters; parameter != null; parameter = (Parameter)parameter.next) {
    //            resolvedTypeGenericArgumentCount++;

    //            parameter.resolve(context, true);
    //            parameter.isEverUsed = true;
    //            if (parameter.variableType != VariableType.outParameter) {
    //                parameter.setAssigned(context);
    //            }

    //            // 参数不能同名。
    //            for (var p = parameters; p != parameter; p = (Parameter)p.next) {
    //                if (p.name.value == parameter.name.value) {
    //                    Compiler.error(ErrorCode.none, String.Format("当前方法已经包含名为“{0}”的参数", parameter.name.value), parameter.name);
    //                    paramSuccess = false;
    //                    break;
    //                }
    //            }

    //            // 检查参数类型。
    //            if (parameter.type != null) {
    //                parameter.resolvedType = parameter.type.resolveAsType(context.currentMemberDefinition, MemberUsage.type);
    //                if (parameter.resolvedType == null) {
    //                    paramSuccess = false;
    //                    continue;
    //                }
    //                ResolveHelper.checkVaribaleType(parameter.resolvedType, parameter.type);
    //            }

    //        }

    //        return paramSuccess;

    //    }

    //    TypeReference _resolvedType;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前表达式到指定类型的转换类型。
    //    /// </summary>
    //    /// <param name="targetType">要转换的目标类型。</param>
    //    /// <returns>获取转换方式。</returns>
    //    public override ConversionType classifyConversion(TypeReference targetType) {

    //        // 如果当前方法已解析，则直接确定返回类型是否符合要求。
    //        if (_resolvedType != null) {
    //            return ResolveHelper.classifyConversion(this, _resolvedType, targetType);
    //        }

    //        // 确认目标类型是 Func<...>
    //        if (targetType.underlyingType != PredefinedTypes.System_Func_T) {
    //            return ConversionType.none;
    //        }

    //        // 确认目标类型的参数个数符合要求。
    //        if (resolvedTypeGenericArgumentCount != targetType.genericArguments.Length) {
    //            return ConversionType.none;
    //        }

    //        return ConversionType.identity;
    //    }

    //}

    //#endregion

    //#region ShimExpressions

    ///// <summary>
    ///// 表示一个括号表达式。
    ///// </summary>
    //public partial class ParenthesizedExpression {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return body.resolveAsValue(context);
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为值解析，然后隐式转换为指定的类型，同时允许更新 var 的含义。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="declareType">声明的类型。如果需要则更新声明类型。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast) {
    //        return body.resolveAsValue(context, expectedType, explicitCast);
    //    }

    //}

    ///// <summary>
    ///// 表示一组逗号隔开的表达式。
    ///// </summary>
    //public partial class CommaExpression {

    //    /// <summary>
    //    /// 报告当前节点不可访问的警告。
    //    /// </summary>
    //    /// <returns>如果已输出警告信息则返回 true，否则返回 false。</returns>
    //    public override bool reportUnreachableCodeWarning() {
    //        return left.reportUnreachableCodeWarning() || right.reportUnreachableCodeWarning();
    //    }

    //    /// <summary>
    //    /// 对当前语句执行语义分析。
    //    /// </summary>
    //    /// <param name="context">包含所有解析状态的上下文对象。</param>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        left = left.resolveAsValue(context);
    //        right = right.resolveAsValue(context);
    //        if (left == null || right == null) {
    //            return null;
    //        }
    //        return this;
    //    }

    //}

    ///// <summary>
    ///// 表示一个三元条件表达式。
    ///// </summary>
    //public partial class ConditionalExpression {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return resolveAsValue(context, null);
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为值解析，然后隐式转换为指定的类型，同时允许更新 var 的含义。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="declareType">声明的类型。如果需要则更新声明类型。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast = State.unset) {

    //        // 执行条件部分。
    //        condition = condition.resolveAsValue(context, PredefinedTypes.System_Bool);

    //        // 执行 then 部分。
    //        bool doFlowControl = context.currentFlowControl != null;
    //        if (doFlowControl) {
    //            context.enterFlowControl(new SelectionFlowControl(context.currentFlowControl));
    //        }

    //        if (condition == BoolConstant.@false && !(doFlowControl && context.currentFlowControl.currentBranching.isJumped)) {
    //            thenExpression.reportUnreachableCodeWarning();
    //            if (doFlowControl) {
    //                context.currentFlowControl.currentBranching.isJumped = true;
    //            }
    //        }
    //        if (expectedType == null) {
    //            thenExpression = thenExpression.resolveAsValue(context);
    //        } else {
    //            thenExpression = thenExpression.resolveAsValue(context, expectedType);
    //        }

    //        // 执行 else 部分。
    //        if (doFlowControl) {
    //            context.currentFlowControl.addBranching();
    //        }

    //        if (condition == BoolConstant.@true && !(doFlowControl && context.currentFlowControl.currentBranching.isJumped)) {
    //            elseExpression.reportUnreachableCodeWarning();
    //            if (doFlowControl) {
    //                context.currentFlowControl.currentBranching.isJumped = true;
    //            }
    //        }
    //        if (expectedType == null) {
    //            elseExpression = elseExpression.resolveAsValue(context);
    //        } else {
    //            elseExpression = elseExpression.resolveAsValue(context, expectedType);
    //        }

    //        if (doFlowControl) {
    //            context.exitFlowControl();
    //        }

    //        if (condition == null || thenExpression == null || elseExpression == null) {
    //            return null;
    //        }

    //        _resolvedType = ResolveHelper.getCommonBaseType(thenExpression.resolvedType, elseExpression.resolvedType);
    //        return this;
    //    }

    //    TypeReference _resolvedType;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前表达式转为指定的类型。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="expectedType">期待的返回类型。</param>
    //    public void convertTo(ResolveContext context, TypeReference expectedType) {

    //    }

    //}

    ///// <summary>
    ///// 表示一个类型转换表达式。
    ///// </summary>
    //public partial class CastExpression {

    //    /// <summary>
    //    /// 将当前表达式作为值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        var type = targetType.resolveAsType(context.currentMemberDefinition, MemberUsage.@typeof);
    //        if (type == null) {
    //            return body.resolveAsValue(context);
    //        }
    //        ResolveHelper.checkVaribaleType(type, targetType);
    //        return body.resolveAsValue(context, type, State.on);
    //    }

    //}

    //#endregion

    //#region CallExpression

    ///// <summary>
    ///// 表示一个函数调用表达式。
    ///// </summary>
    //public partial class FuncCallExpression {

    //    /// <summary>
    //    /// 表示函数调用的参数。
    //    /// </summary>
    //    public partial class Argument {

    //        /// <summary>
    //        /// 获取当前参数值解析后的符号对象。
    //        /// </summary>
    //        public Expression resolvedValue;

    //    }

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        Expression instance;
    //        var resolvedTarget = target.resolveAsSymbol(context, SymbolUsage.getValue, out instance);
    //        if (resolvedTarget == null) {
    //            return null;
    //        }

    //        return resolvedTarget.invoke(context, instance, arguments, this);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 new 表达式。
    ///// </summary>
    //public partial class NewExpression : FuncCallExpression {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {

    //        // 解析类型。
    //        var resolvedTarget = target.resolveAsType(context.currentMemberDefinition, MemberUsage.type);
    //        if (resolvedTarget == null) {
    //            return null;
    //        }

    //        // 解析构造函数。
    //        var resolvedConsturctorCall = ResolveHelper.invoke(context, resolvedTarget.getAllConstrutors(), null, arguments, this);

    //        var creation = new ObjectCreationExpression() {
    //            target = resolvedTarget,
    //            constructorInvocation = resolvedConsturctorCall
    //        };

    //        if (initializer == null) {
    //            return creation;
    //        }

    //        // 解析初始化值。
    //        if (initializer is ListLiteral) {
    //            return ((ListLiteral)initializer).resolveAsValue(context, creation, true);
    //        }

    //        Debug.Assert(initializer is DictLiteral);
    //        return ((DictLiteral)initializer).resolveAsValue(context, creation, true);
    //    }

    //}

    ///// <summary>
    ///// 表示一个索引调用表达式。
    ///// </summary>
    //public partial class IndexCallExpression : FuncCallExpression {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        var resolvedTarget = target.resolveAsValue(context);
    //        if (resolvedTarget == null) {
    //            return null;
    //        }

    //        var members = resolvedTarget.resolvedType.getAllMembers("@[]");
    //        if (members == null) {
    //            Compiler.error(ErrorCode.none, String.Format("“{0}”不存在“[]”的操作符重载", target.resolvedType.fullName), target);
    //            return null;
    //        }

    //        return ResolveHelper.invoke(context, members, resolvedTarget, arguments, this);
    //    }

    //}

    ///// <summary>
    ///// 表示一个链式成员访问表达式。
    ///// </summary>
    //public partial class ChainExpression {

    //    public override TypeReference resolvedType {
    //        get {
    //            return chainCallExpression.target.resolvedType ;
    //        }
    //    }

    //    public override Expression resolveAsValue(ResolveContext context) {
    //        body = body.resolveAsValue(context);
    //        if (body == null) {
    //            return null;
    //        }
    //         return this;
    //    }

    //    public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast) {
    //        body = body.resolveAsValue(context, expectedType, explicitCast);
    //        if (body == null) {
    //            return null;
    //        }
    //        return this;
    //    }

    //}

    //#endregion

    //#region ArithmeticExpression

    ///// <summary>
    ///// 表示一个一元运算表达式。
    ///// </summary>
    //public partial class UnaryExpression {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        switch (@operator) {
    //            case TokenType.not:
    //                return resolveNot(context);

    //            case TokenType.add:
    //                return resolveAdd(context);

    //            case TokenType.sub:
    //                return resolveSub(context);

    //            case TokenType.varAnd:
    //                return resolveAddressOf(context);
    //            case TokenType.mul:
    //                return resolveValueOf(context);

    //            case TokenType.bitComplement:
    //                return resolveBitComplement(context);

    //            default:
    //                throw new Unreachable();
    //        }
    //    }

    //    private Expression resolveNot(ResolveContext context) {
    //        operand = operand.resolveAsValue(context, PredefinedTypes.System_Bool);
    //        if (operand == null) {
    //            return null;
    //        }
    //        if (operand is Constant) {
    //            return BoolConstant.from(operand != BoolConstant.@true);
    //        }
    //        _returnType = PredefinedTypes.System_Bool;
    //        return this;
    //    }

    //    private Expression resolveAdd(ResolveContext context) {
    //        var value = operand.resolveAsValue(context);
    //        if (value == null) {
    //            return null;
    //        }
    //        switch (value.resolvedType.primitiveType) {
    //            case PrimitiveType.none:
    //                return resolveUserDefinedUnaryOperator(context);
    //            case PrimitiveType.@byte:
    //            case PrimitiveType.int16:
    //            case PrimitiveType.uint16:
    //                value = ResolveHelper.convertTo(value, PredefinedTypes.System_Int32, State.unset, operand);
    //                break;
    //            case PrimitiveType.int32:
    //            case PrimitiveType.uint32:
    //            case PrimitiveType.int64:
    //            case PrimitiveType.uint64:
    //            case PrimitiveType.float32:
    //            case PrimitiveType.float64:
    //                break;
    //            default:
    //                reportOperatorError();
    //                return null;
    //        }

    //        Constant valueConstant = value as Constant;
    //        if (valueConstant != null) {
    //            return valueConstant.calc(@operator);
    //        }

    //        return value;
    //    }

    //    private Expression resolveSub(ResolveContext context) {
    //        var value = operand.resolveAsValue(context);
    //        if (value == null) {
    //            return null;
    //        }
    //        switch (value.resolvedType.primitiveType) {
    //            case PrimitiveType.none:
    //                return resolveUserDefinedUnaryOperator(context);
    //            case PrimitiveType.@byte:
    //            case PrimitiveType.int16:
    //            case PrimitiveType.uint16:
    //                value = ResolveHelper.convertTo(value, PredefinedTypes.System_Int32, State.unset, operand);
    //                break;
    //            case PrimitiveType.uint32:
    //            case PrimitiveType.int64:
    //                value = ResolveHelper.convertTo(value, PredefinedTypes.System_Int64, State.unset, operand);
    //                break;
    //            case PrimitiveType.int32:
    //            case PrimitiveType.float32:
    //            case PrimitiveType.float64:
    //                break;
    //            default:
    //                reportOperatorError();
    //                return null;
    //        }

    //        Constant valueConstant = value as Constant;
    //        if (valueConstant != null) {
    //            return valueConstant.calc(@operator);
    //        }

    //        _returnType = value.resolvedType;
    //        return this;
    //    }

    //    private Expression resolveAddressOf(ResolveContext context) {
    //        Expression instance;
    //        var resolvedSymbol = operand.resolveAsSymbol(context, SymbolUsage.getSetValue, out instance);
    //        if (resolvedSymbol == null) {
    //            return null;
    //        }

    //        return resolvedSymbol.addressOf(context, instance, operand);
    //    }

    //    private Expression resolveValueOf(ResolveContext context) {
    //        operand = operand.resolveAsValue(context);
    //        if (operand == null) {
    //            return null;
    //        }
    //        if (operand.resolvedType.primitiveType != PrimitiveType.ptr) {
    //            reportOperatorError();
    //            return null;
    //        }

    //        _returnType = operand.resolvedType.genericArguments[0];
    //        if (_returnType == PredefinedTypes.@void) {
    //            reportOperatorError();
    //            return null;
    //        }
    //        return this;
    //    }

    //    private Expression resolveBitComplement(ResolveContext context) {
    //        var value = operand.resolveAsValue(context);
    //        if (value == null) {
    //            return null;
    //        }
    //        switch (value.resolvedType.primitiveType) {
    //            case PrimitiveType.none:
    //                return resolveUserDefinedUnaryOperator(context);
    //            case PrimitiveType.@byte:
    //            case PrimitiveType.int16:
    //            case PrimitiveType.uint16:
    //                value = ResolveHelper.convertTo(value, PredefinedTypes.System_Int32, State.unset, operand);
    //                break;
    //            case PrimitiveType.int32:
    //            case PrimitiveType.uint32:
    //            case PrimitiveType.int64:
    //            case PrimitiveType.uint64:
    //                break;
    //            default:
    //                reportOperatorError();
    //                return null;
    //        }

    //        Constant valueConstant = value as Constant;
    //        if (valueConstant != null) {
    //            return valueConstant.calc(@operator);
    //        }

    //        _returnType = value.resolvedType;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 获取当前操作返回类型。
    //    /// </summary>
    //    TypeReference _returnType;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _returnType;
    //        }
    //    }

    //    protected Expression resolveUserDefinedUnaryOperator(ResolveContext context) {
    //        return ResolveHelper.invoke(context, @operator, operand, this);
    //    }

    //    protected void reportOperatorError() {
    //        Compiler.error(ErrorCode.none, String.Format("“{0}”无法使用“{1}”运算符", @operator.getName(), operand.resolvedType.fullName), this);
    //    }


    //}

    ///// <summary>
    ///// 表示一个 typeof 或 sizeof 表达式。
    ///// </summary>
    //public abstract partial class TypeOrSizeOfExpression {

    //    /// <summary>
    //    /// 获取当前表达式解析后的目标类型。
    //    /// </summary>
    //    public TypeReference targetType;

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        var member = operand.resolveAsMember(context.currentMemberDefinition, MemberUsage.@typeof);
    //        targetType = member as TypeReference;

    //        if (targetType == null) {
    //            if (member != null) {
    //                Compiler.error(ErrorCode.none, String.Format("应输入类型（“{0}”是{1}，不是类型）", member.fullName, member.memberType.getReadableName()), this);
    //                return null;
    //            }
    //            return null;
    //        }

    //        return this;
    //    }

    //}

    ///// <summary>
    ///// 表示一个 typeof 表达式。
    ///// </summary>
    //public partial class TypeOfExpression : TypeOrSizeOfExpression {

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Reflection_Type;
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个 sizeof 表达式。
    ///// </summary>
    //public partial class SizeOfExpression : TypeOrSizeOfExpression {

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Int32;
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个 ++ 或 -- 运算表达式。
    ///// </summary>
    //public partial class MutatorExpression : UnaryExpression {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {

    //        // 目标表达式必须可赋值。
    //        Expression instance;
    //        var operandSymbol = operand.resolveAsSymbol(context, SymbolUsage.getSetValue, out instance);
    //        if (operandSymbol == null) {
    //            return null;
    //        }

    //        // 解析目标表达式。
    //        Expression value = operandSymbol.getValue(context, instance, operand);
    //        if (value == null) {
    //            return null;
    //        }
    //        Expression rightValue;
    //        switch (value.resolvedType.primitiveType) {
    //            case PrimitiveType.none:
    //                return resolveUserDefinedUnaryOperator(context);
    //            case PrimitiveType.@byte:
    //            case PrimitiveType.int16:
    //            case PrimitiveType.uint16:
    //            case PrimitiveType.int32:
    //                rightValue = Int32Constant.from(1);
    //                break;
    //            case PrimitiveType.uint32:
    //                rightValue = Int64Constant.from(1U);
    //                break;
    //            case PrimitiveType.int64:
    //                rightValue = Int64Constant.from(1L);
    //                break;
    //            case PrimitiveType.uint64:
    //                rightValue = UInt64Constant.from(1UL);
    //                break;
    //            case PrimitiveType.float32:
    //                rightValue = Float32Constant.from(1F);
    //                break;
    //            case PrimitiveType.float64:
    //                rightValue = Float64Constant.from(1D);
    //                break;
    //            default:
    //                reportOperatorError();
    //                return null;
    //        }

    //        return operandSymbol.setValue(context, instance, new CompilerGeneratedExpression() {
    //            body = ResolveHelper.convertTo(new BinaryExpression() {
    //                leftOperand = value,
    //                @operator = @operator == TokenType.inc ? TokenType.add : TokenType.sub,
    //                rightOperand = rightValue,
    //                returnType = rightValue.resolvedType,
    //            }, value.resolvedType, State.unset, operand)
    //        }, operand);
    //    }

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return operand.resolvedType;
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个二元运算表达式。
    ///// </summary>
    //public partial class BinaryExpression {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {

    //        switch (@operator) {
    //            case TokenType.assign:
    //                return resolveAssignOperator(context);
    //            case TokenType.assignTo:
    //                return resolveAssignToOperator(context);
    //            case TokenType.logicalAnd:
    //            case TokenType.logicalOr:
    //                return resolveLogicalOperator(context);
    //            case TokenType.eq:
    //            case TokenType.ne:
    //            case TokenType.lt:
    //            case TokenType.lte:
    //            case TokenType.gt:
    //            case TokenType.gte:
    //                return resolveComparionOperator(context);
    //            case TokenType.add:
    //            case TokenType.assignAdd:
    //            case TokenType.sub:
    //            case TokenType.assignSub:
    //            case TokenType.mul:
    //            case TokenType.assignMul:
    //            case TokenType.div:
    //            case TokenType.assignDiv:
    //            case TokenType.mod:
    //            case TokenType.assignMod:
    //            case TokenType.pow:
    //                return resolveArithmeticOperator(context);
    //            case TokenType.varAnd:
    //            case TokenType.assignVarAnd:
    //            case TokenType.varOr:
    //            case TokenType.assignVarOr:
    //                return resolveVariableOperator(context);
    //            case TokenType.bitShl:
    //            case TokenType.bitShr:
    //                return resolveShiftOperator(context);
    //            case TokenType.bitXor:
    //            case TokenType.bitOr:
    //            case TokenType.bitAnd:
    //                return resolveBitwiseOperator(context);
    //            default:
    //                throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前操作返回类型。
    //    /// </summary>
    //    public TypeReference returnType;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return returnType;
    //        }
    //    }

    //    private Expression resolveAssignOperator(ResolveContext context) {
    //        Expression instance;
    //        var left = leftOperand.resolveAsSymbol(context, SymbolUsage.setValue, out instance);
    //        if (left == null) {
    //            return null;
    //        }
    //        return left.setValue(context, instance, rightOperand, leftOperand);
    //    }

    //    private Expression resolveAssignToOperator(ResolveContext context) {
    //        Expression instance;
    //        var right = rightOperand.resolveAsSymbol(context, SymbolUsage.define, out instance);
    //        if (right == null) {
    //            return null;
    //        }
    //        return right.setValue(context, instance, leftOperand, rightOperand);
    //    }

    //    private Expression resolveLogicalOperator(ResolveContext context) {

    //        bool doFlowControl = context.currentFlowControl != null;
    //        var left = leftOperand.resolveAsValue(context, PredefinedTypes.System_Bool);

    //        if (doFlowControl) {
    //            context.enterFlowControl(new SelectionFlowControl(context.currentFlowControl));
    //        }

    //        State rightState = State.off;

    //        Constant leftConstant = left as Constant;
    //        if (leftConstant != null) {
    //            if (leftConstant == BoolConstant.@true) {
    //                if (@operator == TokenType.logicalOr) {
    //                    rightOperand.reportUnreachableCodeWarning();
    //                    rightState = State.off;
    //                } else {
    //                    rightState = State.on;
    //                }
    //            } else {
    //                Debug.Assert(leftConstant == BoolConstant.@false);
    //                if (@operator == TokenType.logicalAnd) {
    //                    rightOperand.reportUnreachableCodeWarning();
    //                    rightState = State.off;
    //                } else {
    //                    rightState = State.on;
    //                }
    //            }
    //        }

    //        var right = rightOperand.resolveAsValue(context, PredefinedTypes.System_Bool);

    //        if (doFlowControl) {
    //            if (rightState == State.on) {
    //                context.exitFlowControl();
    //            } else {
    //                context.exitFlowControlWithoutSave();
    //            }
    //        }

    //        if (left == null || right == null) {
    //            return null;
    //        }

    //        if (rightState != State.unset) {
    //            return rightState == State.on ? right : left;
    //        }

    //        leftOperand = left;
    //        rightOperand = right;
    //        returnType = PredefinedTypes.System_Bool;
    //        return this;

    //    }

    //    private Expression resolveComparionOperator(ResolveContext context) {
    //        Expression leftInstance;
    //        Expression rightInstance;
    //        var leftSymbol = leftOperand.resolveAsSymbol(context, SymbolUsage.getValue, out leftInstance);
    //        var rightSymbol = rightOperand.resolveAsSymbol(context, SymbolUsage.getValue, out rightInstance);
    //        if (leftSymbol == null || rightSymbol == null) {
    //            return null;
    //        }

    //        if (leftSymbol == rightSymbol && leftInstance == rightInstance) {
    //            Compiler.warning(ErrorCode.none, "对同一个变量进行比较，是否有拼写错误?", this);
    //        }

    //        var left = leftSymbol.getValue(context, leftInstance, leftOperand);
    //        var right = rightSymbol.getValue(context, rightInstance, rightOperand);
    //        if (left == null || right == null) {
    //            return null;
    //        }

    //        // 处理用户自定义操作符重载。
    //        if (left.resolvedType.primitiveType == PrimitiveType.none || right.resolvedType.primitiveType == PrimitiveType.none) {
    //            return resolveUserDefinedBinaryOperator(context, left, right);
    //        }

    //        // bool 支持 == 和 != 操作。
    //        if (promoteType(ref left, ref right) == PrimitiveType.none && !(left.resolvedType == PredefinedTypes.System_Bool && right.resolvedType == PredefinedTypes.System_Bool && (@operator == TokenType.eq || @operator == TokenType.ne))) {
    //            reportOperatorError();
    //            return null;
    //        }

    //        var leftConstant = left as Constant;
    //        var rightConstant = right as Constant;
    //        if (leftConstant != null && rightConstant != null) {
    //            return leftConstant.calc(@operator, rightConstant);
    //        }

    //        leftOperand = left;
    //        rightOperand = right;
    //        returnType = PredefinedTypes.System_Bool;
    //        return this;
    //    }

    //    private Expression resolveArithmeticOperator(ResolveContext context) {

    //        bool isAssign = @operator.isAssignOperator();

    //        Expression left;
    //        ISymbol leftSymbol = null;
    //        Expression leftInstance = null;
    //        if (isAssign) {
    //            leftSymbol = leftOperand.resolveAsSymbol(context, SymbolUsage.getSetValue, out leftInstance);
    //            if (leftSymbol != null) {
    //                left = leftSymbol.getValue(context, leftInstance, leftOperand);
    //            } else {
    //                left = null;
    //            }
    //        } else {
    //            left = leftOperand.resolveAsValue(context);
    //        }

    //        var right = rightOperand.resolveAsValue(context);
    //        if (left == null || right == null) {
    //            return null;
    //        }

    //        // 处理用户自定义操作符。
    //        if (left.resolvedType.primitiveType == PrimitiveType.none || right.resolvedType.primitiveType == PrimitiveType.none) {
    //            return resolveUserDefinedBinaryOperator(context, left, right);
    //        }

    //        // 处理预定义操作符。
    //        if (promoteType(ref left, ref right) == PrimitiveType.none) {
    //            reportOperatorError();
    //            return null;
    //        }

    //        var leftConstant = left as Constant;
    //        var rightConstant = right as Constant;

    //        // 检查被 0 除错误。
    //        if (rightConstant != null && @operator == TokenType.div && rightConstant.resolvedType != PredefinedTypes.System_Float32 && rightConstant.resolvedType != PredefinedTypes.System_Float64 && rightConstant.int64Value == 0) {
    //            Compiler.error(ErrorCode.none, "被 0 除", rightOperand);
    //            return null;
    //        }

    //        if (leftConstant != null && rightConstant != null) {
    //            return leftConstant.calc(@operator, rightConstant);
    //        }

    //        leftOperand = left;
    //        rightOperand = right;
    //        returnType = leftOperand.resolvedType;

    //        if (isAssign) {
    //            return leftSymbol.setValue(context, leftInstance, new CompilerGeneratedExpression() {
    //                body = this
    //            }, leftOperand);
    //        }

    //        return this;

    //    }

    //    private PrimitiveType promoteType(ref Expression left, ref Expression right) {

    //        var leftPrimitiveType = left.resolvedType.primitiveType;
    //        var rightPrimitiveType = right.resolvedType.primitiveType;

    //        if (leftPrimitiveType == PrimitiveType.float64 || rightPrimitiveType == PrimitiveType.float64) {
    //            left = ResolveHelper.convertTo(left, PredefinedTypes.System_Float64, State.unset, leftOperand);
    //            right = ResolveHelper.convertTo(right, PredefinedTypes.System_Float64, State.unset, rightOperand);
    //            return PrimitiveType.float64;
    //        }

    //        if (leftPrimitiveType == PrimitiveType.float32 || rightPrimitiveType == PrimitiveType.float32) {
    //            left = ResolveHelper.convertTo(left, PredefinedTypes.System_Float32, State.unset, leftOperand);
    //            right = ResolveHelper.convertTo(right, PredefinedTypes.System_Float32, State.unset, rightOperand);
    //            return PrimitiveType.float32;
    //        }

    //        if (leftPrimitiveType == PrimitiveType.uint64) {
    //            if (rightPrimitiveType == PrimitiveType.int64 || rightPrimitiveType == PrimitiveType.int32 || rightPrimitiveType == PrimitiveType.int16) {
    //                return PrimitiveType.none;
    //            }

    //            right = ResolveHelper.convertTo(right, PredefinedTypes.System_UInt64, State.unset, rightOperand);
    //            return PrimitiveType.uint64;
    //        }

    //        if (rightPrimitiveType == PrimitiveType.uint64) {
    //            if (leftPrimitiveType == PrimitiveType.int64 || leftPrimitiveType == PrimitiveType.int32 || leftPrimitiveType == PrimitiveType.int16) {
    //                return PrimitiveType.none;
    //            }

    //            left = ResolveHelper.convertTo(left, PredefinedTypes.System_UInt64, State.unset, leftOperand);
    //            return PrimitiveType.uint64;
    //        }

    //        if (leftPrimitiveType == PrimitiveType.int64 || rightPrimitiveType == PrimitiveType.int64) {
    //            left = ResolveHelper.convertTo(left, PredefinedTypes.System_Int64, State.unset, leftOperand);
    //            right = ResolveHelper.convertTo(right, PredefinedTypes.System_Int64, State.unset, rightOperand);
    //            return PrimitiveType.int64;
    //        }

    //        if (leftPrimitiveType == PrimitiveType.uint32) {
    //            if (rightPrimitiveType == PrimitiveType.int32 || rightPrimitiveType == PrimitiveType.int16) {
    //                left = ResolveHelper.convertTo(left, PredefinedTypes.System_Int64, State.unset, leftOperand);
    //                right = ResolveHelper.convertTo(right, PredefinedTypes.System_Int64, State.unset, rightOperand);
    //                return PrimitiveType.none;
    //            }

    //            right = ResolveHelper.convertTo(right, PredefinedTypes.System_UInt32, State.unset, rightOperand);
    //            return PrimitiveType.uint32;
    //        }

    //        if (rightPrimitiveType == PrimitiveType.uint32) {
    //            if (leftPrimitiveType == PrimitiveType.int32 || leftPrimitiveType == PrimitiveType.int16) {
    //                left = ResolveHelper.convertTo(left, PredefinedTypes.System_Int64, State.unset, leftOperand);
    //                right = ResolveHelper.convertTo(right, PredefinedTypes.System_Int64, State.unset, rightOperand);
    //                return PrimitiveType.none;
    //            }

    //            left = ResolveHelper.convertTo(left, PredefinedTypes.System_UInt32, State.unset, leftOperand);
    //            return PrimitiveType.uint32;
    //        }

    //        if (leftPrimitiveType == PrimitiveType.@bool || rightPrimitiveType == PrimitiveType.@bool) {
    //            return PrimitiveType.none;
    //        }

    //        left = ResolveHelper.convertTo(left, PredefinedTypes.System_Int32, State.unset, leftOperand);
    //        right = ResolveHelper.convertTo(right, PredefinedTypes.System_Int32, State.unset, rightOperand);
    //        return PrimitiveType.int32;
    //    }

    //    private Expression resolveVariableOperator(ResolveContext context) {
    //        throw new NotImplementedException();
    //    }

    //    private Expression resolveBitwiseOperator(ResolveContext context) {
    //        var left = leftOperand.resolveAsValue(context);
    //        var right = rightOperand.resolveAsValue(context);
    //        if (left == null || right == null) {
    //            return null;
    //        }

    //        // 处理用户自定义操作符。
    //        if (left.resolvedType.primitiveType == PrimitiveType.none || right.resolvedType.primitiveType == PrimitiveType.none) {
    //            return resolveUserDefinedBinaryOperator(context, left, right);
    //        }

    //        // 布尔允许进行计算。
    //        switch (promoteType(ref left, ref right)) {
    //            case PrimitiveType.none:
    //                if (!(left.resolvedType == PredefinedTypes.System_Bool && right.resolvedType == PredefinedTypes.System_Bool)) {
    //                    goto case PrimitiveType.float32;
    //                }
    //                break;
    //            case PrimitiveType.float64:
    //            case PrimitiveType.float32:
    //                reportOperatorError();
    //                return null;
    //        }

    //        var leftConstant = left as Constant;
    //        var rightConstant = right as Constant;
    //        if (leftConstant != null && rightConstant != null) {
    //            return leftConstant.calc(@operator, rightConstant);
    //        }

    //        leftOperand = left;
    //        rightOperand = right;
    //        returnType = leftOperand.resolvedType;
    //        return this;
    //    }

    //    private Expression resolveShiftOperator(ResolveContext context) {
    //        var left = leftOperand.resolveAsValue(context);
    //        var right = rightOperand.resolveAsValue(context, PredefinedTypes.System_Int32);
    //        if (left == null || right == null) {
    //            return null;
    //        }

    //        // 处理用户自定义操作符。
    //        if (left.resolvedType.primitiveType == PrimitiveType.none) {
    //            return resolveUserDefinedBinaryOperator(context, left, right);
    //        }

    //        switch (left.resolvedType.primitiveType) {
    //            case PrimitiveType.none:
    //            case PrimitiveType.@byte:
    //            case PrimitiveType.int16:
    //            case PrimitiveType.uint16:
    //                left = ResolveHelper.convertTo(left, PredefinedTypes.System_Int32, State.unset, leftOperand);
    //                break;
    //            case PrimitiveType.int32:
    //            case PrimitiveType.uint32:
    //            case PrimitiveType.int64:
    //            case PrimitiveType.uint64:
    //                break;
    //            default:
    //                reportOperatorError();
    //                return null;
    //        }

    //        var leftConstant = left as Constant;
    //        var rightConstant = right as Constant;
    //        if (leftConstant != null && rightConstant != null) {
    //            return leftConstant.calc(@operator, rightConstant);
    //        }

    //        leftOperand = left;
    //        rightOperand = right;
    //        returnType = leftOperand.resolvedType;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 解析用户自定义的操作符。
    //    /// </summary>
    //    /// <param name="context"></param>
    //    /// <param name="leftVal"></param>
    //    /// <param name="rightVal"></param>
    //    /// <returns></returns>
    //    public Expression resolveUserDefinedBinaryOperator(ResolveContext context, Expression left, Expression right) {
    //        return ResolveHelper.invoke(context, left, @operator, right, this);
    //    }

    //    private void reportOperatorError() {
    //        Compiler.error(ErrorCode.none, String.Format("“{1}”和“{2}”之间无法使用“{0}”运算符", @operator.getName(), leftOperand.resolvedType.fullName, rightOperand.resolvedType.fullName), this);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 is 表达式。
    ///// </summary>
    //public partial class IsExpression : IsOrAsExpression {

    //    /// <summary>
    //    /// 获取当前表达式解析后的目标类型。
    //    /// </summary>
    //    public TypeReference targetType;

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {

    //        var left = leftOperand.resolveAsValue(context);
    //        var right = rightOperand.resolveAsType(context.currentMemberDefinition, MemberUsage.@typeof);
    //        if (left == null || right == null) {
    //            return null;
    //        }

    //        ResolveHelper.checkVaribaleType(right, rightOperand);

    //        // null is Type
    //        // (void) is Type
    //        if (left == NullConstant.@default || left.resolvedType == PredefinedTypes.@void) {
    //            Compiler.warning(ErrorCode.none, String.Format("所给表达式始终不是“{0}”类型", right.fullName), rightOperand);
    //            return BoolConstant.@false;
    //        }

    //        // * is dynamic
    //        if (right == PredefinedTypes.dynamic) {
    //            Compiler.error(ErrorCode.none, "“dynamic”在此处无效", rightOperand);
    //            return BoolConstant.@true;
    //        }

    //        switch (ResolveHelper.classifyConversion(left, left.resolvedType, right)) {
    //            case ConversionType.none:
    //                Compiler.warning(ErrorCode.none, String.Format("所给表达式始终不是“{0}”类型", right.fullName), this);
    //                return BoolConstant.@false;
    //            case ConversionType.identity:
    //            case ConversionType.implicitConstant:
    //            case ConversionType.implicitNumeric:
    //            case ConversionType.implicitReference:
    //                Compiler.warning(ErrorCode.none, String.Format("所给表达式始终是“{0}”类型", right.fullName), this);
    //                return BoolConstant.@true;
    //            default:
    //                leftOperand = left;
    //                targetType = right;
    //                return this;
    //        }

    //    }

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Bool;
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个 as 表达式。
    ///// </summary>
    //public partial class AsExpression : IsOrAsExpression {

    //    /// <summary>
    //    /// 将当前表达式作为右值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        var type = rightOperand.resolveAsType(context.currentMemberDefinition, MemberUsage.@typeof);
    //        if (type == null) {
    //            return leftOperand.resolveAsValue(context);
    //        }

    //        return leftOperand.resolveAsValue(context, type, State.off);
    //    }

    //}

    //#endregion

}